// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

#[allow(unused_imports)]
use super::*;

#[cfg(feature = "agents")]
impl std::fmt::Debug for super::Agent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Agent");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("default_language_code", &self.default_language_code);
        debug_struct.field("supported_language_codes", &self.supported_language_codes);
        debug_struct.field("time_zone", &self.time_zone);
        debug_struct.field("description", &self.description);
        debug_struct.field("avatar_uri", &self.avatar_uri);
        debug_struct.field("enable_logging", &self.enable_logging);
        debug_struct.field("match_mode", &self.match_mode);
        debug_struct.field("classification_threshold", &self.classification_threshold);
        debug_struct.field("api_version", &self.api_version);
        debug_struct.field("tier", &self.tier);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "agents")]
impl std::fmt::Debug for super::GetAgentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetAgentRequest");
        debug_struct.field("parent", &self.parent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "agents")]
impl std::fmt::Debug for super::SetAgentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SetAgentRequest");
        debug_struct.field("agent", &self.agent);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "agents")]
impl std::fmt::Debug for super::DeleteAgentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteAgentRequest");
        debug_struct.field("parent", &self.parent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "agents")]
impl std::fmt::Debug for super::SearchAgentsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchAgentsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "agents")]
impl std::fmt::Debug for super::SearchAgentsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchAgentsResponse");
        debug_struct.field("agents", &self.agents);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "agents")]
impl std::fmt::Debug for super::TrainAgentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TrainAgentRequest");
        debug_struct.field("parent", &self.parent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "agents")]
impl std::fmt::Debug for super::ExportAgentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportAgentRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("agent_uri", &self.agent_uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "agents")]
impl std::fmt::Debug for super::ExportAgentResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportAgentResponse");
        debug_struct.field("agent", &self.agent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "agents")]
impl std::fmt::Debug for super::ImportAgentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportAgentRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("agent", &self.agent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "agents")]
impl std::fmt::Debug for super::RestoreAgentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("RestoreAgentRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("agent", &self.agent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "agents")]
impl std::fmt::Debug for super::GetValidationResultRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetValidationResultRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("language_code", &self.language_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "answer-records")]
impl std::fmt::Debug for super::AnswerRecord {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AnswerRecord");
        debug_struct.field("name", &self.name);
        debug_struct.field("answer_feedback", &self.answer_feedback);
        debug_struct.field("record", &self.record);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "answer-records")]
impl std::fmt::Debug for super::ListAnswerRecordsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListAnswerRecordsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "answer-records")]
impl std::fmt::Debug for super::ListAnswerRecordsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListAnswerRecordsResponse");
        debug_struct.field("answer_records", &self.answer_records);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "answer-records")]
impl std::fmt::Debug for super::UpdateAnswerRecordRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateAnswerRecordRequest");
        debug_struct.field("answer_record", &self.answer_record);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "answer-records")]
impl std::fmt::Debug for super::AnswerFeedback {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AnswerFeedback");
        debug_struct.field("correctness_level", &self.correctness_level);
        debug_struct.field("clicked", &self.clicked);
        debug_struct.field("click_time", &self.click_time);
        debug_struct.field("displayed", &self.displayed);
        debug_struct.field("display_time", &self.display_time);
        debug_struct.field("detail_feedback", &self.detail_feedback);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "answer-records")]
impl std::fmt::Debug for super::AgentAssistantFeedback {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AgentAssistantFeedback");
        debug_struct.field("answer_relevance", &self.answer_relevance);
        debug_struct.field("document_correctness", &self.document_correctness);
        debug_struct.field("document_efficiency", &self.document_efficiency);
        debug_struct.field("summarization_feedback", &self.summarization_feedback);
        debug_struct.field("knowledge_search_feedback", &self.knowledge_search_feedback);
        debug_struct.field("knowledge_assist_feedback", &self.knowledge_assist_feedback);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "answer-records")]
impl std::fmt::Debug for super::agent_assistant_feedback::SummarizationFeedback {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationFeedback");
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("submit_time", &self.submit_time);
        debug_struct.field("summary_text", &self.summary_text);
        debug_struct.field("text_sections", &self.text_sections);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "answer-records")]
impl std::fmt::Debug for super::agent_assistant_feedback::KnowledgeSearchFeedback {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("KnowledgeSearchFeedback");
        debug_struct.field("answer_copied", &self.answer_copied);
        debug_struct.field("clicked_uris", &self.clicked_uris);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "answer-records")]
impl std::fmt::Debug for super::agent_assistant_feedback::KnowledgeAssistFeedback {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("KnowledgeAssistFeedback");
        debug_struct.field("answer_copied", &self.answer_copied);
        debug_struct.field("clicked_uris", &self.clicked_uris);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "answer-records")]
impl std::fmt::Debug for super::AgentAssistantRecord {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AgentAssistantRecord");
        debug_struct.field("answer", &self.answer);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "participants", feature = "sessions",))]
impl std::fmt::Debug for super::SpeechContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SpeechContext");
        debug_struct.field("phrases", &self.phrases);
        debug_struct.field("boost", &self.boost);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "participants", feature = "sessions",))]
impl std::fmt::Debug for super::SpeechWordInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SpeechWordInfo");
        debug_struct.field("word", &self.word);
        debug_struct.field("start_offset", &self.start_offset);
        debug_struct.field("end_offset", &self.end_offset);
        debug_struct.field("confidence", &self.confidence);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "participants", feature = "sessions",))]
impl std::fmt::Debug for super::InputAudioConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InputAudioConfig");
        debug_struct.field("audio_encoding", &self.audio_encoding);
        debug_struct.field("sample_rate_hertz", &self.sample_rate_hertz);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("enable_word_info", &self.enable_word_info);
        debug_struct.field("phrase_hints", &self.phrase_hints);
        debug_struct.field("speech_contexts", &self.speech_contexts);
        debug_struct.field("model", &self.model);
        debug_struct.field("model_variant", &self.model_variant);
        debug_struct.field("single_utterance", &self.single_utterance);
        debug_struct.field(
            "disable_no_speech_recognized_event",
            &self.disable_no_speech_recognized_event,
        );
        debug_struct.field(
            "enable_automatic_punctuation",
            &self.enable_automatic_punctuation,
        );
        debug_struct.field("phrase_sets", &self.phrase_sets);
        debug_struct.field(
            "opt_out_conformer_model_migration",
            &self.opt_out_conformer_model_migration,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "conversation-profiles",
    feature = "conversations",
    feature = "environments",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::VoiceSelectionParams {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("VoiceSelectionParams");
        debug_struct.field("name", &self.name);
        debug_struct.field("ssml_gender", &self.ssml_gender);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "conversation-profiles",
    feature = "conversations",
    feature = "environments",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::SynthesizeSpeechConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SynthesizeSpeechConfig");
        debug_struct.field("speaking_rate", &self.speaking_rate);
        debug_struct.field("pitch", &self.pitch);
        debug_struct.field("volume_gain_db", &self.volume_gain_db);
        debug_struct.field("effects_profile_id", &self.effects_profile_id);
        debug_struct.field("voice", &self.voice);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "participants", feature = "sessions",))]
impl std::fmt::Debug for super::OutputAudioConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OutputAudioConfig");
        debug_struct.field("audio_encoding", &self.audio_encoding);
        debug_struct.field("sample_rate_hertz", &self.sample_rate_hertz);
        debug_struct.field("synthesize_speech_config", &self.synthesize_speech_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::TelephonyDtmfEvents {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TelephonyDtmfEvents");
        debug_struct.field("dtmf_events", &self.dtmf_events);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::SpeechToTextConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SpeechToTextConfig");
        debug_struct.field("speech_model_variant", &self.speech_model_variant);
        debug_struct.field("model", &self.model);
        debug_struct.field("phrase_sets", &self.phrase_sets);
        debug_struct.field("audio_encoding", &self.audio_encoding);
        debug_struct.field("sample_rate_hertz", &self.sample_rate_hertz);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("enable_word_info", &self.enable_word_info);
        debug_struct.field(
            "use_timeout_based_endpointing",
            &self.use_timeout_based_endpointing,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "contexts",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::Context {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Context");
        debug_struct.field("name", &self.name);
        debug_struct.field("lifespan_count", &self.lifespan_count);
        debug_struct.field("parameters", &self.parameters);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "contexts")]
impl std::fmt::Debug for super::ListContextsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListContextsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "contexts")]
impl std::fmt::Debug for super::ListContextsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListContextsResponse");
        debug_struct.field("contexts", &self.contexts);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "contexts")]
impl std::fmt::Debug for super::GetContextRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetContextRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "contexts")]
impl std::fmt::Debug for super::CreateContextRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateContextRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("context", &self.context);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "contexts")]
impl std::fmt::Debug for super::UpdateContextRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateContextRequest");
        debug_struct.field("context", &self.context);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "contexts")]
impl std::fmt::Debug for super::DeleteContextRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteContextRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "contexts")]
impl std::fmt::Debug for super::DeleteAllContextsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteAllContextsRequest");
        debug_struct.field("parent", &self.parent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::Conversation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Conversation");
        debug_struct.field("name", &self.name);
        debug_struct.field("lifecycle_state", &self.lifecycle_state);
        debug_struct.field("conversation_profile", &self.conversation_profile);
        debug_struct.field("phone_number", &self.phone_number);
        debug_struct.field("start_time", &self.start_time);
        debug_struct.field("end_time", &self.end_time);
        debug_struct.field("conversation_stage", &self.conversation_stage);
        debug_struct.field("telephony_connection_info", &self.telephony_connection_info);
        debug_struct.field(
            "ingested_context_references",
            &self.ingested_context_references,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::conversation::TelephonyConnectionInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TelephonyConnectionInfo");
        debug_struct.field("dialed_number", &self.dialed_number);
        debug_struct.field("sdp", &self.sdp);
        debug_struct.field("sip_headers", &self.sip_headers);
        debug_struct.field("extra_mime_contents", &self.extra_mime_contents);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::conversation::telephony_connection_info::SipHeader {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SipHeader");
        debug_struct.field("name", &self.name);
        debug_struct.field("value", &self.value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::conversation::telephony_connection_info::MimeContent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MimeContent");
        debug_struct.field("mime_type", &self.mime_type);
        debug_struct.field("content", &self.content);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::conversation::ContextReference {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ContextReference");
        debug_struct.field("context_contents", &self.context_contents);
        debug_struct.field("update_mode", &self.update_mode);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("create_time", &self.create_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::conversation::context_reference::ContextContent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ContextContent");
        debug_struct.field("content", &self.content);
        debug_struct.field("content_format", &self.content_format);
        debug_struct.field("ingestion_time", &self.ingestion_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::CreateConversationRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateConversationRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("conversation", &self.conversation);
        debug_struct.field("conversation_id", &self.conversation_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::ListConversationsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListConversationsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::ListConversationsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListConversationsResponse");
        debug_struct.field("conversations", &self.conversations);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::GetConversationRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetConversationRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::CompleteConversationRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CompleteConversationRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::ListMessagesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListMessagesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("filter", &self.filter);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::ListMessagesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListMessagesResponse");
        debug_struct.field("messages", &self.messages);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::ConversationPhoneNumber {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConversationPhoneNumber");
        debug_struct.field("country_code", &self.country_code);
        debug_struct.field("phone_number", &self.phone_number);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::IngestContextReferencesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IngestContextReferencesRequest");
        debug_struct.field("conversation", &self.conversation);
        debug_struct.field("context_references", &self.context_references);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::IngestContextReferencesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IngestContextReferencesResponse");
        debug_struct.field(
            "ingested_context_references",
            &self.ingested_context_references,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::SuggestConversationSummaryRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestConversationSummaryRequest");
        debug_struct.field("conversation", &self.conversation);
        debug_struct.field("latest_message", &self.latest_message);
        debug_struct.field("context_size", &self.context_size);
        debug_struct.field("assist_query_params", &self.assist_query_params);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::SuggestConversationSummaryResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestConversationSummaryResponse");
        debug_struct.field("summary", &self.summary);
        debug_struct.field("latest_message", &self.latest_message);
        debug_struct.field("context_size", &self.context_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::suggest_conversation_summary_response::Summary {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Summary");
        debug_struct.field("text", &self.text);
        debug_struct.field("text_sections", &self.text_sections);
        debug_struct.field("answer_record", &self.answer_record);
        debug_struct.field("baseline_model_version", &self.baseline_model_version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::GenerateStatelessSummaryRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateStatelessSummaryRequest");
        debug_struct.field("stateless_conversation", &self.stateless_conversation);
        debug_struct.field("conversation_profile", &self.conversation_profile);
        debug_struct.field("latest_message", &self.latest_message);
        debug_struct.field("max_context_size", &self.max_context_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::generate_stateless_summary_request::MinimalConversation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MinimalConversation");
        debug_struct.field("messages", &self.messages);
        debug_struct.field("parent", &self.parent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::GenerateStatelessSummaryResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateStatelessSummaryResponse");
        debug_struct.field("summary", &self.summary);
        debug_struct.field("latest_message", &self.latest_message);
        debug_struct.field("context_size", &self.context_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::generate_stateless_summary_response::Summary {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Summary");
        debug_struct.field("text", &self.text);
        debug_struct.field("text_sections", &self.text_sections);
        debug_struct.field("baseline_model_version", &self.baseline_model_version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::GenerateStatelessSuggestionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateStatelessSuggestionRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("context_references", &self.context_references);
        debug_struct.field("conversation_context", &self.conversation_context);
        debug_struct.field("trigger_events", &self.trigger_events);
        debug_struct.field("generator_resource", &self.generator_resource);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::GenerateStatelessSuggestionResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateStatelessSuggestionResponse");
        debug_struct.field("generator_suggestion", &self.generator_suggestion);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::SearchKnowledgeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchKnowledgeRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("query", &self.query);
        debug_struct.field("conversation_profile", &self.conversation_profile);
        debug_struct.field("session_id", &self.session_id);
        debug_struct.field("conversation", &self.conversation);
        debug_struct.field("latest_message", &self.latest_message);
        debug_struct.field("query_source", &self.query_source);
        debug_struct.field("end_user_metadata", &self.end_user_metadata);
        debug_struct.field("search_config", &self.search_config);
        debug_struct.field("exact_search", &self.exact_search);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::search_knowledge_request::SearchConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchConfig");
        debug_struct.field("boost_specs", &self.boost_specs);
        debug_struct.field("filter_specs", &self.filter_specs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::search_knowledge_request::search_config::BoostSpecs {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BoostSpecs");
        debug_struct.field("data_stores", &self.data_stores);
        debug_struct.field("spec", &self.spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::search_knowledge_request::search_config::boost_specs::BoostSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BoostSpec");
        debug_struct.field("condition_boost_specs", &self.condition_boost_specs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug
    for super::search_knowledge_request::search_config::boost_specs::boost_spec::ConditionBoostSpec
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConditionBoostSpec");
        debug_struct.field("condition", &self.condition);
        debug_struct.field("boost", &self.boost);
        debug_struct.field("boost_control_spec", &self.boost_control_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::search_knowledge_request::search_config::boost_specs::boost_spec::condition_boost_spec::BoostControlSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BoostControlSpec");
        debug_struct.field("field_name", &self.field_name);
        debug_struct.field("attribute_type", &self.attribute_type);
        debug_struct.field("interpolation_type", &self.interpolation_type);
        debug_struct.field("control_points", &self.control_points);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::search_knowledge_request::search_config::boost_specs::boost_spec::condition_boost_spec::boost_control_spec::ControlPoint {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ControlPoint");
        debug_struct.field("attribute_value", &self.attribute_value);
        debug_struct.field("boost_amount", &self.boost_amount);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::search_knowledge_request::search_config::FilterSpecs {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FilterSpecs");
        debug_struct.field("data_stores", &self.data_stores);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::SearchKnowledgeResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchKnowledgeResponse");
        debug_struct.field("answers", &self.answers);
        debug_struct.field("rewritten_query", &self.rewritten_query);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::SearchKnowledgeAnswer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SearchKnowledgeAnswer");
        debug_struct.field("answer", &self.answer);
        debug_struct.field("answer_type", &self.answer_type);
        debug_struct.field("answer_sources", &self.answer_sources);
        debug_struct.field("answer_record", &self.answer_record);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::search_knowledge_answer::AnswerSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AnswerSource");
        debug_struct.field("title", &self.title);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("snippet", &self.snippet);
        debug_struct.field("metadata", &self.metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversations")]
impl std::fmt::Debug for super::GenerateSuggestionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateSuggestionsRequest");
        debug_struct.field("conversation", &self.conversation);
        debug_struct.field("latest_message", &self.latest_message);
        debug_struct.field("trigger_events", &self.trigger_events);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-datasets")]
impl std::fmt::Debug for super::ConversationInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConversationInfo");
        debug_struct.field("language_code", &self.language_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-datasets")]
impl std::fmt::Debug for super::InputConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InputConfig");
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-datasets")]
impl std::fmt::Debug for super::ConversationDataset {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConversationDataset");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("input_config", &self.input_config);
        debug_struct.field("conversation_info", &self.conversation_info);
        debug_struct.field("conversation_count", &self.conversation_count);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-datasets")]
impl std::fmt::Debug for super::CreateConversationDatasetRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateConversationDatasetRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("conversation_dataset", &self.conversation_dataset);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-datasets")]
impl std::fmt::Debug for super::GetConversationDatasetRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetConversationDatasetRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-datasets")]
impl std::fmt::Debug for super::ListConversationDatasetsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListConversationDatasetsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-datasets")]
impl std::fmt::Debug for super::ListConversationDatasetsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListConversationDatasetsResponse");
        debug_struct.field("conversation_datasets", &self.conversation_datasets);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-datasets")]
impl std::fmt::Debug for super::DeleteConversationDatasetRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteConversationDatasetRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-datasets")]
impl std::fmt::Debug for super::ImportConversationDataRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportConversationDataRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("input_config", &self.input_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-datasets")]
impl std::fmt::Debug for super::ImportConversationDataOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportConversationDataOperationMetadata");
        debug_struct.field("conversation_dataset", &self.conversation_dataset);
        debug_struct.field("partial_failures", &self.partial_failures);
        debug_struct.field("create_time", &self.create_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-datasets")]
impl std::fmt::Debug for super::ImportConversationDataOperationResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportConversationDataOperationResponse");
        debug_struct.field("conversation_dataset", &self.conversation_dataset);
        debug_struct.field("import_count", &self.import_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-datasets")]
impl std::fmt::Debug for super::CreateConversationDatasetOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateConversationDatasetOperationMetadata");
        debug_struct.field("conversation_dataset", &self.conversation_dataset);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-datasets")]
impl std::fmt::Debug for super::DeleteConversationDatasetOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteConversationDatasetOperationMetadata");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(all(
    feature = "agents",
    feature = "answer-records",
    feature = "contexts",
    feature = "conversation-datasets",
    feature = "conversation-models",
    feature = "conversation-profiles",
    feature = "conversations",
    feature = "documents",
    feature = "encryption-spec-service",
    feature = "entity-types",
    feature = "environments",
    feature = "fulfillments",
    feature = "generators",
    feature = "intents",
    feature = "knowledge-bases",
    feature = "participants",
    feature = "session-entity-types",
    feature = "sessions",
    feature = "versions",
))]
impl std::fmt::Debug for super::ConversationEvent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConversationEvent");
        debug_struct.field("conversation", &self.conversation);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("error_status", &self.error_status);
        debug_struct.field("payload", &self.payload);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::ConversationModel {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConversationModel");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("datasets", &self.datasets);
        debug_struct.field("state", &self.state);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("satisfies_pzs", &self.satisfies_pzs);
        debug_struct.field("satisfies_pzi", &self.satisfies_pzi);
        debug_struct.field("model_metadata", &self.model_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::ConversationModelEvaluation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConversationModelEvaluation");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("evaluation_config", &self.evaluation_config);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field(
            "raw_human_eval_template_csv",
            &self.raw_human_eval_template_csv,
        );
        debug_struct.field("metrics", &self.metrics);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::EvaluationConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EvaluationConfig");
        debug_struct.field("datasets", &self.datasets);
        debug_struct.field("model_specific_config", &self.model_specific_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::evaluation_config::SmartReplyConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SmartReplyConfig");
        debug_struct.field("allowlist_document", &self.allowlist_document);
        debug_struct.field("max_result_count", &self.max_result_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::evaluation_config::SmartComposeConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SmartComposeConfig");
        debug_struct.field("allowlist_document", &self.allowlist_document);
        debug_struct.field("max_result_count", &self.max_result_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::InputDataset {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InputDataset");
        debug_struct.field("dataset", &self.dataset);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::ArticleSuggestionModelMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ArticleSuggestionModelMetadata");
        debug_struct.field("training_model_type", &self.training_model_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::SmartReplyModelMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SmartReplyModelMetadata");
        debug_struct.field("training_model_type", &self.training_model_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::SmartReplyMetrics {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SmartReplyMetrics");
        debug_struct.field("allowlist_coverage", &self.allowlist_coverage);
        debug_struct.field("top_n_metrics", &self.top_n_metrics);
        debug_struct.field("conversation_count", &self.conversation_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::smart_reply_metrics::TopNMetrics {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TopNMetrics");
        debug_struct.field("n", &self.n);
        debug_struct.field("recall", &self.recall);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::CreateConversationModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateConversationModelRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("conversation_model", &self.conversation_model);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::GetConversationModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetConversationModelRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::ListConversationModelsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListConversationModelsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::ListConversationModelsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListConversationModelsResponse");
        debug_struct.field("conversation_models", &self.conversation_models);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::DeleteConversationModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteConversationModelRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::DeployConversationModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployConversationModelRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::UndeployConversationModelRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UndeployConversationModelRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::GetConversationModelEvaluationRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetConversationModelEvaluationRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::ListConversationModelEvaluationsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListConversationModelEvaluationsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::ListConversationModelEvaluationsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListConversationModelEvaluationsResponse");
        debug_struct.field(
            "conversation_model_evaluations",
            &self.conversation_model_evaluations,
        );
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::CreateConversationModelEvaluationRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateConversationModelEvaluationRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field(
            "conversation_model_evaluation",
            &self.conversation_model_evaluation,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::CreateConversationModelOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateConversationModelOperationMetadata");
        debug_struct.field("conversation_model", &self.conversation_model);
        debug_struct.field("state", &self.state);
        debug_struct.field("create_time", &self.create_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::DeployConversationModelOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeployConversationModelOperationMetadata");
        debug_struct.field("conversation_model", &self.conversation_model);
        debug_struct.field("create_time", &self.create_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::UndeployConversationModelOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UndeployConversationModelOperationMetadata");
        debug_struct.field("conversation_model", &self.conversation_model);
        debug_struct.field("create_time", &self.create_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::DeleteConversationModelOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteConversationModelOperationMetadata");
        debug_struct.field("conversation_model", &self.conversation_model);
        debug_struct.field("create_time", &self.create_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-models")]
impl std::fmt::Debug for super::CreateConversationModelEvaluationOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateConversationModelEvaluationOperationMetadata");
        debug_struct.field(
            "conversation_model_evaluation",
            &self.conversation_model_evaluation,
        );
        debug_struct.field("conversation_model", &self.conversation_model);
        debug_struct.field("state", &self.state);
        debug_struct.field("create_time", &self.create_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::ConversationProfile {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConversationProfile");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("automated_agent_config", &self.automated_agent_config);
        debug_struct.field(
            "human_agent_assistant_config",
            &self.human_agent_assistant_config,
        );
        debug_struct.field(
            "human_agent_handoff_config",
            &self.human_agent_handoff_config,
        );
        debug_struct.field("notification_config", &self.notification_config);
        debug_struct.field("logging_config", &self.logging_config);
        debug_struct.field(
            "new_message_event_notification_config",
            &self.new_message_event_notification_config,
        );
        debug_struct.field(
            "new_recognition_result_notification_config",
            &self.new_recognition_result_notification_config,
        );
        debug_struct.field("stt_config", &self.stt_config);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("time_zone", &self.time_zone);
        debug_struct.field("security_settings", &self.security_settings);
        debug_struct.field("tts_config", &self.tts_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-profiles")]
impl std::fmt::Debug for super::ListConversationProfilesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListConversationProfilesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-profiles")]
impl std::fmt::Debug for super::ListConversationProfilesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListConversationProfilesResponse");
        debug_struct.field("conversation_profiles", &self.conversation_profiles);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-profiles")]
impl std::fmt::Debug for super::GetConversationProfileRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetConversationProfileRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-profiles")]
impl std::fmt::Debug for super::CreateConversationProfileRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateConversationProfileRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("conversation_profile", &self.conversation_profile);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-profiles")]
impl std::fmt::Debug for super::UpdateConversationProfileRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateConversationProfileRequest");
        debug_struct.field("conversation_profile", &self.conversation_profile);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-profiles")]
impl std::fmt::Debug for super::DeleteConversationProfileRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteConversationProfileRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::AutomatedAgentConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutomatedAgentConfig");
        debug_struct.field("agent", &self.agent);
        debug_struct.field("session_ttl", &self.session_ttl);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::HumanAgentAssistantConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("HumanAgentAssistantConfig");
        debug_struct.field("notification_config", &self.notification_config);
        debug_struct.field(
            "human_agent_suggestion_config",
            &self.human_agent_suggestion_config,
        );
        debug_struct.field(
            "end_user_suggestion_config",
            &self.end_user_suggestion_config,
        );
        debug_struct.field("message_analysis_config", &self.message_analysis_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::human_agent_assistant_config::SuggestionTriggerSettings {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestionTriggerSettings");
        debug_struct.field("no_smalltalk", &self.no_smalltalk);
        debug_struct.field("only_end_user", &self.only_end_user);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::human_agent_assistant_config::SuggestionFeatureConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestionFeatureConfig");
        debug_struct.field("suggestion_feature", &self.suggestion_feature);
        debug_struct.field(
            "enable_event_based_suggestion",
            &self.enable_event_based_suggestion,
        );
        debug_struct.field(
            "disable_agent_query_logging",
            &self.disable_agent_query_logging,
        );
        debug_struct.field(
            "enable_query_suggestion_when_no_answer",
            &self.enable_query_suggestion_when_no_answer,
        );
        debug_struct.field(
            "enable_conversation_augmented_query",
            &self.enable_conversation_augmented_query,
        );
        debug_struct.field(
            "enable_query_suggestion_only",
            &self.enable_query_suggestion_only,
        );
        debug_struct.field(
            "suggestion_trigger_settings",
            &self.suggestion_trigger_settings,
        );
        debug_struct.field("query_config", &self.query_config);
        debug_struct.field("conversation_model_config", &self.conversation_model_config);
        debug_struct.field(
            "conversation_process_config",
            &self.conversation_process_config,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::human_agent_assistant_config::SuggestionConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestionConfig");
        debug_struct.field("feature_configs", &self.feature_configs);
        debug_struct.field(
            "group_suggestion_responses",
            &self.group_suggestion_responses,
        );
        debug_struct.field("generators", &self.generators);
        debug_struct.field(
            "disable_high_latency_features_sync_delivery",
            &self.disable_high_latency_features_sync_delivery,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::human_agent_assistant_config::SuggestionQueryConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestionQueryConfig");
        debug_struct.field("max_results", &self.max_results);
        debug_struct.field("confidence_threshold", &self.confidence_threshold);
        debug_struct.field("context_filter_settings", &self.context_filter_settings);
        debug_struct.field("sections", &self.sections);
        debug_struct.field("context_size", &self.context_size);
        debug_struct.field("query_source", &self.query_source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug
    for super::human_agent_assistant_config::suggestion_query_config::KnowledgeBaseQuerySource
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("KnowledgeBaseQuerySource");
        debug_struct.field("knowledge_bases", &self.knowledge_bases);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug
    for super::human_agent_assistant_config::suggestion_query_config::DocumentQuerySource
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DocumentQuerySource");
        debug_struct.field("documents", &self.documents);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug
    for super::human_agent_assistant_config::suggestion_query_config::DialogflowQuerySource
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DialogflowQuerySource");
        debug_struct.field("agent", &self.agent);
        debug_struct.field("human_agent_side_config", &self.human_agent_side_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::human_agent_assistant_config::suggestion_query_config::dialogflow_query_source::HumanAgentSideConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("HumanAgentSideConfig");
        debug_struct.field("agent", &self.agent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug
    for super::human_agent_assistant_config::suggestion_query_config::ContextFilterSettings
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ContextFilterSettings");
        debug_struct.field("drop_handoff_messages", &self.drop_handoff_messages);
        debug_struct.field(
            "drop_virtual_agent_messages",
            &self.drop_virtual_agent_messages,
        );
        debug_struct.field("drop_ivr_messages", &self.drop_ivr_messages);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::human_agent_assistant_config::suggestion_query_config::Sections {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Sections");
        debug_struct.field("section_types", &self.section_types);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::human_agent_assistant_config::ConversationModelConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConversationModelConfig");
        debug_struct.field("model", &self.model);
        debug_struct.field("baseline_model_version", &self.baseline_model_version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::human_agent_assistant_config::ConversationProcessConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConversationProcessConfig");
        debug_struct.field("recent_sentences_count", &self.recent_sentences_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::human_agent_assistant_config::MessageAnalysisConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MessageAnalysisConfig");
        debug_struct.field("enable_entity_extraction", &self.enable_entity_extraction);
        debug_struct.field("enable_sentiment_analysis", &self.enable_sentiment_analysis);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::HumanAgentHandoffConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("HumanAgentHandoffConfig");
        debug_struct.field("agent_service", &self.agent_service);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::human_agent_handoff_config::LivePersonConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LivePersonConfig");
        debug_struct.field("account_number", &self.account_number);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::human_agent_handoff_config::SalesforceLiveAgentConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SalesforceLiveAgentConfig");
        debug_struct.field("organization_id", &self.organization_id);
        debug_struct.field("deployment_id", &self.deployment_id);
        debug_struct.field("button_id", &self.button_id);
        debug_struct.field("endpoint_domain", &self.endpoint_domain);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::NotificationConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("NotificationConfig");
        debug_struct.field("topic", &self.topic);
        debug_struct.field("message_format", &self.message_format);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::LoggingConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LoggingConfig");
        debug_struct.field(
            "enable_stackdriver_logging",
            &self.enable_stackdriver_logging,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-profiles", feature = "conversations",))]
impl std::fmt::Debug for super::SuggestionFeature {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestionFeature");
        debug_struct.field("r#type", &self.r#type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-profiles")]
impl std::fmt::Debug for super::SetSuggestionFeatureConfigRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SetSuggestionFeatureConfigRequest");
        debug_struct.field("conversation_profile", &self.conversation_profile);
        debug_struct.field("participant_role", &self.participant_role);
        debug_struct.field("suggestion_feature_config", &self.suggestion_feature_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-profiles")]
impl std::fmt::Debug for super::ClearSuggestionFeatureConfigRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ClearSuggestionFeatureConfigRequest");
        debug_struct.field("conversation_profile", &self.conversation_profile);
        debug_struct.field("participant_role", &self.participant_role);
        debug_struct.field("suggestion_feature_type", &self.suggestion_feature_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-profiles")]
impl std::fmt::Debug for super::SetSuggestionFeatureConfigOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SetSuggestionFeatureConfigOperationMetadata");
        debug_struct.field("conversation_profile", &self.conversation_profile);
        debug_struct.field("participant_role", &self.participant_role);
        debug_struct.field("suggestion_feature_type", &self.suggestion_feature_type);
        debug_struct.field("create_time", &self.create_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "conversation-profiles")]
impl std::fmt::Debug for super::ClearSuggestionFeatureConfigOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ClearSuggestionFeatureConfigOperationMetadata");
        debug_struct.field("conversation_profile", &self.conversation_profile);
        debug_struct.field("participant_role", &self.participant_role);
        debug_struct.field("suggestion_feature_type", &self.suggestion_feature_type);
        debug_struct.field("create_time", &self.create_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::Document {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Document");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("mime_type", &self.mime_type);
        debug_struct.field("knowledge_types", &self.knowledge_types);
        debug_struct.field("enable_auto_reload", &self.enable_auto_reload);
        debug_struct.field("latest_reload_status", &self.latest_reload_status);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("state", &self.state);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::document::ReloadStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReloadStatus");
        debug_struct.field("time", &self.time);
        debug_struct.field("status", &self.status);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::GetDocumentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetDocumentRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::ListDocumentsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDocumentsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::ListDocumentsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListDocumentsResponse");
        debug_struct.field("documents", &self.documents);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::CreateDocumentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateDocumentRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("document", &self.document);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::ImportDocumentsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportDocumentsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("document_template", &self.document_template);
        debug_struct.field(
            "import_gcs_custom_metadata",
            &self.import_gcs_custom_metadata,
        );
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::ImportDocumentTemplate {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportDocumentTemplate");
        debug_struct.field("mime_type", &self.mime_type);
        debug_struct.field("knowledge_types", &self.knowledge_types);
        debug_struct.field("metadata", &self.metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::ImportDocumentsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ImportDocumentsResponse");
        debug_struct.field("warnings", &self.warnings);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::DeleteDocumentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteDocumentRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::UpdateDocumentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateDocumentRequest");
        debug_struct.field("document", &self.document);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::ReloadDocumentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ReloadDocumentRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field(
            "import_gcs_custom_metadata",
            &self.import_gcs_custom_metadata,
        );
        debug_struct.field(
            "smart_messaging_partial_update",
            &self.smart_messaging_partial_update,
        );
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::ExportDocumentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportDocumentRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("export_full_content", &self.export_full_content);
        debug_struct.field(
            "smart_messaging_partial_update",
            &self.smart_messaging_partial_update,
        );
        debug_struct.field("destination", &self.destination);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::ExportOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ExportOperationMetadata");
        debug_struct.field("exported_gcs_destination", &self.exported_gcs_destination);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::KnowledgeOperationMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("KnowledgeOperationMetadata");
        debug_struct.field("state", &self.state);
        debug_struct.field("knowledge_base", &self.knowledge_base);
        debug_struct.field("operation_metadata", &self.operation_metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "encryption-spec-service")]
impl std::fmt::Debug for super::GetEncryptionSpecRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetEncryptionSpecRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "encryption-spec-service")]
impl std::fmt::Debug for super::EncryptionSpec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EncryptionSpec");
        debug_struct.field("name", &self.name);
        debug_struct.field("kms_key", &self.kms_key);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "encryption-spec-service")]
impl std::fmt::Debug for super::InitializeEncryptionSpecRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InitializeEncryptionSpecRequest");
        debug_struct.field("encryption_spec", &self.encryption_spec);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "encryption-spec-service")]
impl std::fmt::Debug for super::InitializeEncryptionSpecResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InitializeEncryptionSpecResponse");
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "encryption-spec-service")]
impl std::fmt::Debug for super::InitializeEncryptionSpecMetadata {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InitializeEncryptionSpecMetadata");
        debug_struct.field("request", &self.request);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "entity-types",
    feature = "participants",
    feature = "session-entity-types",
    feature = "sessions",
))]
impl std::fmt::Debug for super::EntityType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EntityType");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("kind", &self.kind);
        debug_struct.field("auto_expansion_mode", &self.auto_expansion_mode);
        debug_struct.field("entities", &self.entities);
        debug_struct.field("enable_fuzzy_extraction", &self.enable_fuzzy_extraction);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "entity-types",
    feature = "participants",
    feature = "session-entity-types",
    feature = "sessions",
))]
impl std::fmt::Debug for super::entity_type::Entity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Entity");
        debug_struct.field("value", &self.value);
        debug_struct.field("synonyms", &self.synonyms);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "entity-types")]
impl std::fmt::Debug for super::ListEntityTypesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListEntityTypesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "entity-types")]
impl std::fmt::Debug for super::ListEntityTypesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListEntityTypesResponse");
        debug_struct.field("entity_types", &self.entity_types);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "entity-types")]
impl std::fmt::Debug for super::GetEntityTypeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetEntityTypeRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("language_code", &self.language_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "entity-types")]
impl std::fmt::Debug for super::CreateEntityTypeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateEntityTypeRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("language_code", &self.language_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "entity-types")]
impl std::fmt::Debug for super::UpdateEntityTypeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateEntityTypeRequest");
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "entity-types")]
impl std::fmt::Debug for super::DeleteEntityTypeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteEntityTypeRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "entity-types")]
impl std::fmt::Debug for super::BatchUpdateEntityTypesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchUpdateEntityTypesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("update_mask", &self.update_mask);
        debug_struct.field("entity_type_batch", &self.entity_type_batch);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "entity-types")]
impl std::fmt::Debug for super::BatchUpdateEntityTypesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchUpdateEntityTypesResponse");
        debug_struct.field("entity_types", &self.entity_types);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "entity-types")]
impl std::fmt::Debug for super::BatchDeleteEntityTypesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchDeleteEntityTypesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("entity_type_names", &self.entity_type_names);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "entity-types")]
impl std::fmt::Debug for super::BatchCreateEntitiesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchCreateEntitiesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("entities", &self.entities);
        debug_struct.field("language_code", &self.language_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "entity-types")]
impl std::fmt::Debug for super::BatchUpdateEntitiesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchUpdateEntitiesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("entities", &self.entities);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "entity-types")]
impl std::fmt::Debug for super::BatchDeleteEntitiesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchDeleteEntitiesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("entity_values", &self.entity_values);
        debug_struct.field("language_code", &self.language_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "entity-types")]
impl std::fmt::Debug for super::EntityTypeBatch {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EntityTypeBatch");
        debug_struct.field("entity_types", &self.entity_types);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "environments")]
impl std::fmt::Debug for super::Environment {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Environment");
        debug_struct.field("name", &self.name);
        debug_struct.field("description", &self.description);
        debug_struct.field("agent_version", &self.agent_version);
        debug_struct.field("state", &self.state);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("text_to_speech_settings", &self.text_to_speech_settings);
        debug_struct.field("fulfillment", &self.fulfillment);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "environments")]
impl std::fmt::Debug for super::TextToSpeechSettings {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TextToSpeechSettings");
        debug_struct.field("enable_text_to_speech", &self.enable_text_to_speech);
        debug_struct.field("output_audio_encoding", &self.output_audio_encoding);
        debug_struct.field("sample_rate_hertz", &self.sample_rate_hertz);
        debug_struct.field("synthesize_speech_configs", &self.synthesize_speech_configs);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "environments")]
impl std::fmt::Debug for super::ListEnvironmentsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListEnvironmentsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "environments")]
impl std::fmt::Debug for super::ListEnvironmentsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListEnvironmentsResponse");
        debug_struct.field("environments", &self.environments);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "environments")]
impl std::fmt::Debug for super::GetEnvironmentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetEnvironmentRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "environments")]
impl std::fmt::Debug for super::CreateEnvironmentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateEnvironmentRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("environment", &self.environment);
        debug_struct.field("environment_id", &self.environment_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "environments")]
impl std::fmt::Debug for super::UpdateEnvironmentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateEnvironmentRequest");
        debug_struct.field("environment", &self.environment);
        debug_struct.field("update_mask", &self.update_mask);
        debug_struct.field(
            "allow_load_to_draft_and_discard_changes",
            &self.allow_load_to_draft_and_discard_changes,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "environments")]
impl std::fmt::Debug for super::DeleteEnvironmentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteEnvironmentRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "environments")]
impl std::fmt::Debug for super::GetEnvironmentHistoryRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetEnvironmentHistoryRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "environments")]
impl std::fmt::Debug for super::EnvironmentHistory {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EnvironmentHistory");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("entries", &self.entries);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "environments")]
impl std::fmt::Debug for super::environment_history::Entry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Entry");
        debug_struct.field("agent_version", &self.agent_version);
        debug_struct.field("description", &self.description);
        debug_struct.field("create_time", &self.create_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "environments", feature = "fulfillments",))]
impl std::fmt::Debug for super::Fulfillment {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Fulfillment");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("enabled", &self.enabled);
        debug_struct.field("features", &self.features);
        debug_struct.field("fulfillment", &self.fulfillment);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "environments", feature = "fulfillments",))]
impl std::fmt::Debug for super::fulfillment::GenericWebService {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenericWebService");
        debug_struct.field("uri", &self.uri);
        debug_struct.field("username", &self.username);
        debug_struct.field("password", &self.password);
        debug_struct.field("request_headers", &self.request_headers);
        debug_struct.field("is_cloud_function", &self.is_cloud_function);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "environments", feature = "fulfillments",))]
impl std::fmt::Debug for super::fulfillment::Feature {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Feature");
        debug_struct.field("r#type", &self.r#type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "fulfillments")]
impl std::fmt::Debug for super::GetFulfillmentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetFulfillmentRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "fulfillments")]
impl std::fmt::Debug for super::UpdateFulfillmentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateFulfillmentRequest");
        debug_struct.field("fulfillment", &self.fulfillment);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversation-datasets", feature = "documents",))]
impl std::fmt::Debug for super::GcsSources {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GcsSources");
        debug_struct.field("uris", &self.uris);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "documents")]
impl std::fmt::Debug for super::GcsDestination {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GcsDestination");
        debug_struct.field("uri", &self.uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "generators")]
impl std::fmt::Debug for super::CreateGeneratorRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateGeneratorRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("generator", &self.generator);
        debug_struct.field("generator_id", &self.generator_id);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "generators")]
impl std::fmt::Debug for super::GetGeneratorRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetGeneratorRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "generators")]
impl std::fmt::Debug for super::ListGeneratorsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListGeneratorsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "generators")]
impl std::fmt::Debug for super::ListGeneratorsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListGeneratorsResponse");
        debug_struct.field("generators", &self.generators);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "generators")]
impl std::fmt::Debug for super::DeleteGeneratorRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteGeneratorRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "generators")]
impl std::fmt::Debug for super::UpdateGeneratorRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateGeneratorRequest");
        debug_struct.field("generator", &self.generator);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "generators",))]
impl std::fmt::Debug for super::MessageEntry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MessageEntry");
        debug_struct.field("role", &self.role);
        debug_struct.field("text", &self.text);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("create_time", &self.create_time);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "generators",))]
impl std::fmt::Debug for super::ConversationContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ConversationContext");
        debug_struct.field("message_entries", &self.message_entries);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "generators",))]
impl std::fmt::Debug for super::SummarizationSectionList {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationSectionList");
        debug_struct.field("summarization_sections", &self.summarization_sections);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "generators",))]
impl std::fmt::Debug for super::FewShotExample {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FewShotExample");
        debug_struct.field("conversation_context", &self.conversation_context);
        debug_struct.field("extra_info", &self.extra_info);
        debug_struct.field("output", &self.output);
        debug_struct.field("instruction_list", &self.instruction_list);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "generators",))]
impl std::fmt::Debug for super::InferenceParameter {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InferenceParameter");
        debug_struct.field("max_output_tokens", &self.max_output_tokens);
        debug_struct.field("temperature", &self.temperature);
        debug_struct.field("top_k", &self.top_k);
        debug_struct.field("top_p", &self.top_p);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "generators",))]
impl std::fmt::Debug for super::SummarizationSection {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationSection");
        debug_struct.field("key", &self.key);
        debug_struct.field("definition", &self.definition);
        debug_struct.field("r#type", &self.r#type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "generators",))]
impl std::fmt::Debug for super::SummarizationContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarizationContext");
        debug_struct.field("summarization_sections", &self.summarization_sections);
        debug_struct.field("few_shot_examples", &self.few_shot_examples);
        debug_struct.field("version", &self.version);
        debug_struct.field("output_language_code", &self.output_language_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "generators",))]
impl std::fmt::Debug for super::FreeFormContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FreeFormContext");
        debug_struct.field("text", &self.text);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "generators",))]
impl std::fmt::Debug for super::Generator {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Generator");
        debug_struct.field("name", &self.name);
        debug_struct.field("description", &self.description);
        debug_struct.field("inference_parameter", &self.inference_parameter);
        debug_struct.field("trigger_event", &self.trigger_event);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("update_time", &self.update_time);
        debug_struct.field("context", &self.context);
        debug_struct.field("foundation_model", &self.foundation_model);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "conversations",
    feature = "generators",
    feature = "participants",
))]
impl std::fmt::Debug for super::FreeFormSuggestion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FreeFormSuggestion");
        debug_struct.field("response", &self.response);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "conversations",
    feature = "generators",
    feature = "participants",
))]
impl std::fmt::Debug for super::SummarySuggestion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarySuggestion");
        debug_struct.field("summary_sections", &self.summary_sections);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "conversations",
    feature = "generators",
    feature = "participants",
))]
impl std::fmt::Debug for super::summary_suggestion::SummarySection {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SummarySection");
        debug_struct.field("section", &self.section);
        debug_struct.field("summary", &self.summary);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "conversations",
    feature = "generators",
    feature = "participants",
))]
impl std::fmt::Debug for super::GeneratorSuggestion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GeneratorSuggestion");
        debug_struct.field("suggestion", &self.suggestion);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(all(
    feature = "agents",
    feature = "answer-records",
    feature = "contexts",
    feature = "conversation-datasets",
    feature = "conversation-models",
    feature = "conversation-profiles",
    feature = "conversations",
    feature = "documents",
    feature = "encryption-spec-service",
    feature = "entity-types",
    feature = "environments",
    feature = "fulfillments",
    feature = "generators",
    feature = "intents",
    feature = "knowledge-bases",
    feature = "participants",
    feature = "session-entity-types",
    feature = "sessions",
    feature = "versions",
))]
impl std::fmt::Debug for super::HumanAgentAssistantEvent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("HumanAgentAssistantEvent");
        debug_struct.field("conversation", &self.conversation);
        debug_struct.field("participant", &self.participant);
        debug_struct.field("suggestion_results", &self.suggestion_results);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::Intent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Intent");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("webhook_state", &self.webhook_state);
        debug_struct.field("priority", &self.priority);
        debug_struct.field("is_fallback", &self.is_fallback);
        debug_struct.field("ml_disabled", &self.ml_disabled);
        debug_struct.field("live_agent_handoff", &self.live_agent_handoff);
        debug_struct.field("end_interaction", &self.end_interaction);
        debug_struct.field("input_context_names", &self.input_context_names);
        debug_struct.field("events", &self.events);
        debug_struct.field("training_phrases", &self.training_phrases);
        debug_struct.field("action", &self.action);
        debug_struct.field("output_contexts", &self.output_contexts);
        debug_struct.field("reset_contexts", &self.reset_contexts);
        debug_struct.field("parameters", &self.parameters);
        debug_struct.field("messages", &self.messages);
        debug_struct.field(
            "default_response_platforms",
            &self.default_response_platforms,
        );
        debug_struct.field("root_followup_intent_name", &self.root_followup_intent_name);
        debug_struct.field(
            "parent_followup_intent_name",
            &self.parent_followup_intent_name,
        );
        debug_struct.field("followup_intent_info", &self.followup_intent_info);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::TrainingPhrase {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TrainingPhrase");
        debug_struct.field("name", &self.name);
        debug_struct.field("r#type", &self.r#type);
        debug_struct.field("parts", &self.parts);
        debug_struct.field("times_added_count", &self.times_added_count);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::training_phrase::Part {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Part");
        debug_struct.field("text", &self.text);
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("alias", &self.alias);
        debug_struct.field("user_defined", &self.user_defined);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::Parameter {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Parameter");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("value", &self.value);
        debug_struct.field("default_value", &self.default_value);
        debug_struct.field("entity_type_display_name", &self.entity_type_display_name);
        debug_struct.field("mandatory", &self.mandatory);
        debug_struct.field("prompts", &self.prompts);
        debug_struct.field("is_list", &self.is_list);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::Message {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Message");
        debug_struct.field("platform", &self.platform);
        debug_struct.field("message", &self.message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::Text {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Text");
        debug_struct.field("text", &self.text);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::Image {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Image");
        debug_struct.field("image_uri", &self.image_uri);
        debug_struct.field("accessibility_text", &self.accessibility_text);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::QuickReplies {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QuickReplies");
        debug_struct.field("title", &self.title);
        debug_struct.field("quick_replies", &self.quick_replies);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::Card {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Card");
        debug_struct.field("title", &self.title);
        debug_struct.field("subtitle", &self.subtitle);
        debug_struct.field("image_uri", &self.image_uri);
        debug_struct.field("buttons", &self.buttons);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::card::Button {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Button");
        debug_struct.field("text", &self.text);
        debug_struct.field("postback", &self.postback);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::SimpleResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SimpleResponse");
        debug_struct.field("text_to_speech", &self.text_to_speech);
        debug_struct.field("ssml", &self.ssml);
        debug_struct.field("display_text", &self.display_text);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::SimpleResponses {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SimpleResponses");
        debug_struct.field("simple_responses", &self.simple_responses);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::BasicCard {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BasicCard");
        debug_struct.field("title", &self.title);
        debug_struct.field("subtitle", &self.subtitle);
        debug_struct.field("formatted_text", &self.formatted_text);
        debug_struct.field("image", &self.image);
        debug_struct.field("buttons", &self.buttons);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::basic_card::Button {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Button");
        debug_struct.field("title", &self.title);
        debug_struct.field("open_uri_action", &self.open_uri_action);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::basic_card::button::OpenUriAction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OpenUriAction");
        debug_struct.field("uri", &self.uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::Suggestion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Suggestion");
        debug_struct.field("title", &self.title);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::Suggestions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Suggestions");
        debug_struct.field("suggestions", &self.suggestions);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::LinkOutSuggestion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("LinkOutSuggestion");
        debug_struct.field("destination_name", &self.destination_name);
        debug_struct.field("uri", &self.uri);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::ListSelect {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSelect");
        debug_struct.field("title", &self.title);
        debug_struct.field("items", &self.items);
        debug_struct.field("subtitle", &self.subtitle);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::list_select::Item {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Item");
        debug_struct.field("info", &self.info);
        debug_struct.field("title", &self.title);
        debug_struct.field("description", &self.description);
        debug_struct.field("image", &self.image);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::CarouselSelect {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CarouselSelect");
        debug_struct.field("items", &self.items);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::carousel_select::Item {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Item");
        debug_struct.field("info", &self.info);
        debug_struct.field("title", &self.title);
        debug_struct.field("description", &self.description);
        debug_struct.field("image", &self.image);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::SelectItemInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SelectItemInfo");
        debug_struct.field("key", &self.key);
        debug_struct.field("synonyms", &self.synonyms);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::MediaContent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MediaContent");
        debug_struct.field("media_type", &self.media_type);
        debug_struct.field("media_objects", &self.media_objects);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::media_content::ResponseMediaObject {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ResponseMediaObject");
        debug_struct.field("name", &self.name);
        debug_struct.field("description", &self.description);
        debug_struct.field("content_url", &self.content_url);
        debug_struct.field("image", &self.image);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::BrowseCarouselCard {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BrowseCarouselCard");
        debug_struct.field("items", &self.items);
        debug_struct.field("image_display_options", &self.image_display_options);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::browse_carousel_card::BrowseCarouselCardItem {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BrowseCarouselCardItem");
        debug_struct.field("open_uri_action", &self.open_uri_action);
        debug_struct.field("title", &self.title);
        debug_struct.field("description", &self.description);
        debug_struct.field("image", &self.image);
        debug_struct.field("footer", &self.footer);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug
    for super::intent::message::browse_carousel_card::browse_carousel_card_item::OpenUrlAction
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OpenUrlAction");
        debug_struct.field("url", &self.url);
        debug_struct.field("url_type_hint", &self.url_type_hint);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::TableCard {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TableCard");
        debug_struct.field("title", &self.title);
        debug_struct.field("subtitle", &self.subtitle);
        debug_struct.field("image", &self.image);
        debug_struct.field("column_properties", &self.column_properties);
        debug_struct.field("rows", &self.rows);
        debug_struct.field("buttons", &self.buttons);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::ColumnProperties {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ColumnProperties");
        debug_struct.field("header", &self.header);
        debug_struct.field("horizontal_alignment", &self.horizontal_alignment);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::TableCardRow {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TableCardRow");
        debug_struct.field("cells", &self.cells);
        debug_struct.field("divider_after", &self.divider_after);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::message::TableCardCell {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TableCardCell");
        debug_struct.field("text", &self.text);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "intents",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::intent::FollowupIntentInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FollowupIntentInfo");
        debug_struct.field("followup_intent_name", &self.followup_intent_name);
        debug_struct.field(
            "parent_followup_intent_name",
            &self.parent_followup_intent_name,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "intents")]
impl std::fmt::Debug for super::ListIntentsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListIntentsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("intent_view", &self.intent_view);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "intents")]
impl std::fmt::Debug for super::ListIntentsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListIntentsResponse");
        debug_struct.field("intents", &self.intents);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "intents")]
impl std::fmt::Debug for super::GetIntentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetIntentRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("intent_view", &self.intent_view);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "intents")]
impl std::fmt::Debug for super::CreateIntentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateIntentRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("intent", &self.intent);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("intent_view", &self.intent_view);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "intents")]
impl std::fmt::Debug for super::UpdateIntentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateIntentRequest");
        debug_struct.field("intent", &self.intent);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("update_mask", &self.update_mask);
        debug_struct.field("intent_view", &self.intent_view);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "intents")]
impl std::fmt::Debug for super::DeleteIntentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteIntentRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "intents")]
impl std::fmt::Debug for super::BatchUpdateIntentsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchUpdateIntentsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("update_mask", &self.update_mask);
        debug_struct.field("intent_view", &self.intent_view);
        debug_struct.field("intent_batch", &self.intent_batch);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "intents")]
impl std::fmt::Debug for super::BatchUpdateIntentsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchUpdateIntentsResponse");
        debug_struct.field("intents", &self.intents);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "intents")]
impl std::fmt::Debug for super::BatchDeleteIntentsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("BatchDeleteIntentsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("intents", &self.intents);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "intents")]
impl std::fmt::Debug for super::IntentBatch {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IntentBatch");
        debug_struct.field("intents", &self.intents);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "knowledge-bases")]
impl std::fmt::Debug for super::KnowledgeBase {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("KnowledgeBase");
        debug_struct.field("name", &self.name);
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("language_code", &self.language_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "knowledge-bases")]
impl std::fmt::Debug for super::ListKnowledgeBasesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListKnowledgeBasesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        debug_struct.field("filter", &self.filter);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "knowledge-bases")]
impl std::fmt::Debug for super::ListKnowledgeBasesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListKnowledgeBasesResponse");
        debug_struct.field("knowledge_bases", &self.knowledge_bases);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "knowledge-bases")]
impl std::fmt::Debug for super::GetKnowledgeBaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetKnowledgeBaseRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "knowledge-bases")]
impl std::fmt::Debug for super::CreateKnowledgeBaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateKnowledgeBaseRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("knowledge_base", &self.knowledge_base);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "knowledge-bases")]
impl std::fmt::Debug for super::DeleteKnowledgeBaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteKnowledgeBaseRequest");
        debug_struct.field("name", &self.name);
        debug_struct.field("force", &self.force);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "knowledge-bases")]
impl std::fmt::Debug for super::UpdateKnowledgeBaseRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateKnowledgeBaseRequest");
        debug_struct.field("knowledge_base", &self.knowledge_base);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "conversation-profiles",
    feature = "conversations",
    feature = "participants",
))]
impl std::fmt::Debug for super::Participant {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Participant");
        debug_struct.field("name", &self.name);
        debug_struct.field("role", &self.role);
        debug_struct.field("sip_recording_media_label", &self.sip_recording_media_label);
        debug_struct.field(
            "obfuscated_external_user_id",
            &self.obfuscated_external_user_id,
        );
        debug_struct.field(
            "documents_metadata_filters",
            &self.documents_metadata_filters,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "participants",))]
impl std::fmt::Debug for super::Message {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Message");
        debug_struct.field("name", &self.name);
        debug_struct.field("content", &self.content);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field("participant", &self.participant);
        debug_struct.field("participant_role", &self.participant_role);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("send_time", &self.send_time);
        debug_struct.field("message_annotation", &self.message_annotation);
        debug_struct.field("sentiment_analysis", &self.sentiment_analysis);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::CreateParticipantRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateParticipantRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("participant", &self.participant);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::GetParticipantRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetParticipantRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::ListParticipantsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListParticipantsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::ListParticipantsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListParticipantsResponse");
        debug_struct.field("participants", &self.participants);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::UpdateParticipantRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateParticipantRequest");
        debug_struct.field("participant", &self.participant);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::AnalyzeContentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AnalyzeContentRequest");
        debug_struct.field("participant", &self.participant);
        debug_struct.field("reply_audio_config", &self.reply_audio_config);
        debug_struct.field("query_params", &self.query_params);
        debug_struct.field("assist_query_params", &self.assist_query_params);
        debug_struct.field("cx_parameters", &self.cx_parameters);
        debug_struct.field("request_id", &self.request_id);
        debug_struct.field("input", &self.input);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::DtmfParameters {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DtmfParameters");
        debug_struct.field("accepts_dtmf_input", &self.accepts_dtmf_input);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::AnalyzeContentResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AnalyzeContentResponse");
        debug_struct.field("reply_text", &self.reply_text);
        debug_struct.field("reply_audio", &self.reply_audio);
        debug_struct.field("automated_agent_reply", &self.automated_agent_reply);
        debug_struct.field("message", &self.message);
        debug_struct.field(
            "human_agent_suggestion_results",
            &self.human_agent_suggestion_results,
        );
        debug_struct.field(
            "end_user_suggestion_results",
            &self.end_user_suggestion_results,
        );
        debug_struct.field("dtmf_parameters", &self.dtmf_parameters);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::StreamingAnalyzeContentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamingAnalyzeContentRequest");
        debug_struct.field("participant", &self.participant);
        debug_struct.field("reply_audio_config", &self.reply_audio_config);
        debug_struct.field("query_params", &self.query_params);
        debug_struct.field("assist_query_params", &self.assist_query_params);
        debug_struct.field("cx_parameters", &self.cx_parameters);
        debug_struct.field("enable_extended_streaming", &self.enable_extended_streaming);
        debug_struct.field(
            "enable_partial_automated_agent_reply",
            &self.enable_partial_automated_agent_reply,
        );
        debug_struct.field("enable_debugging_info", &self.enable_debugging_info);
        debug_struct.field("config", &self.config);
        debug_struct.field("input", &self.input);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::StreamingAnalyzeContentResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamingAnalyzeContentResponse");
        debug_struct.field("recognition_result", &self.recognition_result);
        debug_struct.field("reply_text", &self.reply_text);
        debug_struct.field("reply_audio", &self.reply_audio);
        debug_struct.field("automated_agent_reply", &self.automated_agent_reply);
        debug_struct.field("message", &self.message);
        debug_struct.field(
            "human_agent_suggestion_results",
            &self.human_agent_suggestion_results,
        );
        debug_struct.field(
            "end_user_suggestion_results",
            &self.end_user_suggestion_results,
        );
        debug_struct.field("dtmf_parameters", &self.dtmf_parameters);
        debug_struct.field("debugging_info", &self.debugging_info);
        debug_struct.field("speech_model", &self.speech_model);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::SuggestArticlesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestArticlesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("latest_message", &self.latest_message);
        debug_struct.field("context_size", &self.context_size);
        debug_struct.field("assist_query_params", &self.assist_query_params);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::SuggestArticlesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestArticlesResponse");
        debug_struct.field("article_answers", &self.article_answers);
        debug_struct.field("latest_message", &self.latest_message);
        debug_struct.field("context_size", &self.context_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::SuggestFaqAnswersRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestFaqAnswersRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("latest_message", &self.latest_message);
        debug_struct.field("context_size", &self.context_size);
        debug_struct.field("assist_query_params", &self.assist_query_params);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::SuggestFaqAnswersResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestFaqAnswersResponse");
        debug_struct.field("faq_answers", &self.faq_answers);
        debug_struct.field("latest_message", &self.latest_message);
        debug_struct.field("context_size", &self.context_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "participants",))]
impl std::fmt::Debug for super::GenerateSuggestionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerateSuggestionsResponse");
        debug_struct.field(
            "generator_suggestion_answers",
            &self.generator_suggestion_answers,
        );
        debug_struct.field("latest_message", &self.latest_message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "participants",))]
impl std::fmt::Debug for super::generate_suggestions_response::GeneratorSuggestionAnswer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GeneratorSuggestionAnswer");
        debug_struct.field("generator_suggestion", &self.generator_suggestion);
        debug_struct.field("source_generator", &self.source_generator);
        debug_struct.field("answer_record", &self.answer_record);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::SuggestSmartRepliesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestSmartRepliesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("current_text_input", &self.current_text_input);
        debug_struct.field("latest_message", &self.latest_message);
        debug_struct.field("context_size", &self.context_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::SuggestSmartRepliesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestSmartRepliesResponse");
        debug_struct.field("smart_reply_answers", &self.smart_reply_answers);
        debug_struct.field("latest_message", &self.latest_message);
        debug_struct.field("context_size", &self.context_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::AudioInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AudioInput");
        debug_struct.field("config", &self.config);
        debug_struct.field("audio", &self.audio);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::OutputAudio {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OutputAudio");
        debug_struct.field("config", &self.config);
        debug_struct.field("audio", &self.audio);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::AutomatedAgentReply {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AutomatedAgentReply");
        debug_struct.field("detect_intent_response", &self.detect_intent_response);
        debug_struct.field(
            "automated_agent_reply_type",
            &self.automated_agent_reply_type,
        );
        debug_struct.field("allow_cancellation", &self.allow_cancellation);
        debug_struct.field("cx_current_page", &self.cx_current_page);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "answer-records", feature = "participants",))]
impl std::fmt::Debug for super::ArticleAnswer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ArticleAnswer");
        debug_struct.field("title", &self.title);
        debug_struct.field("uri", &self.uri);
        debug_struct.field("snippets", &self.snippets);
        debug_struct.field("confidence", &self.confidence);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("answer_record", &self.answer_record);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "answer-records", feature = "participants",))]
impl std::fmt::Debug for super::FaqAnswer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FaqAnswer");
        debug_struct.field("answer", &self.answer);
        debug_struct.field("confidence", &self.confidence);
        debug_struct.field("question", &self.question);
        debug_struct.field("source", &self.source);
        debug_struct.field("metadata", &self.metadata);
        debug_struct.field("answer_record", &self.answer_record);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::SmartReplyAnswer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SmartReplyAnswer");
        debug_struct.field("reply", &self.reply);
        debug_struct.field("confidence", &self.confidence);
        debug_struct.field("answer_record", &self.answer_record);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "answer-records")]
impl std::fmt::Debug for super::IntentSuggestion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("IntentSuggestion");
        debug_struct.field("display_name", &self.display_name);
        debug_struct.field("description", &self.description);
        debug_struct.field("intent", &self.intent);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "answer-records")]
impl std::fmt::Debug for super::DialogflowAssistAnswer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DialogflowAssistAnswer");
        debug_struct.field("answer_record", &self.answer_record);
        debug_struct.field("result", &self.result);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::SuggestionResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestionResult");
        debug_struct.field("suggestion_response", &self.suggestion_response);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::InputTextConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("InputTextConfig");
        debug_struct.field("language_code", &self.language_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "participants",))]
impl std::fmt::Debug for super::AnnotatedMessagePart {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AnnotatedMessagePart");
        debug_struct.field("text", &self.text);
        debug_struct.field("entity_type", &self.entity_type);
        debug_struct.field("formatted_value", &self.formatted_value);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "participants",))]
impl std::fmt::Debug for super::MessageAnnotation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("MessageAnnotation");
        debug_struct.field("parts", &self.parts);
        debug_struct.field("contain_entities", &self.contain_entities);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::SuggestionInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestionInput");
        debug_struct.field("answer_record", &self.answer_record);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "conversations", feature = "participants",))]
impl std::fmt::Debug for super::AssistQueryParameters {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("AssistQueryParameters");
        debug_struct.field(
            "documents_metadata_filters",
            &self.documents_metadata_filters,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::SuggestKnowledgeAssistRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestKnowledgeAssistRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("latest_message", &self.latest_message);
        debug_struct.field("context_size", &self.context_size);
        debug_struct.field("previous_suggested_query", &self.previous_suggested_query);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::SuggestKnowledgeAssistResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestKnowledgeAssistResponse");
        debug_struct.field("knowledge_assist_answer", &self.knowledge_assist_answer);
        debug_struct.field("latest_message", &self.latest_message);
        debug_struct.field("context_size", &self.context_size);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::KnowledgeAssistAnswer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("KnowledgeAssistAnswer");
        debug_struct.field("suggested_query", &self.suggested_query);
        debug_struct.field("suggested_query_answer", &self.suggested_query_answer);
        debug_struct.field("answer_record", &self.answer_record);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::knowledge_assist_answer::SuggestedQuery {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SuggestedQuery");
        debug_struct.field("query_text", &self.query_text);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::knowledge_assist_answer::KnowledgeAnswer {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("KnowledgeAnswer");
        debug_struct.field("answer_text", &self.answer_text);
        debug_struct.field("source", &self.source);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::knowledge_assist_answer::knowledge_answer::FaqSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("FaqSource");
        debug_struct.field("question", &self.question);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug for super::knowledge_assist_answer::knowledge_answer::GenerativeSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GenerativeSource");
        debug_struct.field("snippets", &self.snippets);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "participants")]
impl std::fmt::Debug
    for super::knowledge_assist_answer::knowledge_answer::generative_source::Snippet
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Snippet");
        debug_struct.field("uri", &self.uri);
        debug_struct.field("text", &self.text);
        debug_struct.field("title", &self.title);
        debug_struct.field("metadata", &self.metadata);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "sessions")]
impl std::fmt::Debug for super::DetectIntentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DetectIntentRequest");
        debug_struct.field("session", &self.session);
        debug_struct.field("query_params", &self.query_params);
        debug_struct.field("query_input", &self.query_input);
        debug_struct.field("output_audio_config", &self.output_audio_config);
        debug_struct.field("output_audio_config_mask", &self.output_audio_config_mask);
        debug_struct.field("input_audio", &self.input_audio);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "participants", feature = "sessions",))]
impl std::fmt::Debug for super::DetectIntentResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DetectIntentResponse");
        debug_struct.field("response_id", &self.response_id);
        debug_struct.field("query_result", &self.query_result);
        debug_struct.field("webhook_status", &self.webhook_status);
        debug_struct.field("output_audio", &self.output_audio);
        debug_struct.field("output_audio_config", &self.output_audio_config);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "participants", feature = "sessions",))]
impl std::fmt::Debug for super::QueryParameters {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryParameters");
        debug_struct.field("time_zone", &self.time_zone);
        debug_struct.field("geo_location", &self.geo_location);
        debug_struct.field("contexts", &self.contexts);
        debug_struct.field("reset_contexts", &self.reset_contexts);
        debug_struct.field("session_entity_types", &self.session_entity_types);
        debug_struct.field("payload", &self.payload);
        debug_struct.field(
            "sentiment_analysis_request_config",
            &self.sentiment_analysis_request_config,
        );
        debug_struct.field("webhook_headers", &self.webhook_headers);
        debug_struct.field("platform", &self.platform);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "sessions")]
impl std::fmt::Debug for super::QueryInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryInput");
        debug_struct.field("input", &self.input);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::QueryResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("QueryResult");
        debug_struct.field("query_text", &self.query_text);
        debug_struct.field("language_code", &self.language_code);
        debug_struct.field(
            "speech_recognition_confidence",
            &self.speech_recognition_confidence,
        );
        debug_struct.field("action", &self.action);
        debug_struct.field("parameters", &self.parameters);
        debug_struct.field(
            "all_required_params_present",
            &self.all_required_params_present,
        );
        debug_struct.field("cancels_slot_filling", &self.cancels_slot_filling);
        debug_struct.field("fulfillment_text", &self.fulfillment_text);
        debug_struct.field("fulfillment_messages", &self.fulfillment_messages);
        debug_struct.field("webhook_source", &self.webhook_source);
        debug_struct.field("webhook_payload", &self.webhook_payload);
        debug_struct.field("output_contexts", &self.output_contexts);
        debug_struct.field("intent", &self.intent);
        debug_struct.field(
            "intent_detection_confidence",
            &self.intent_detection_confidence,
        );
        debug_struct.field("diagnostic_info", &self.diagnostic_info);
        debug_struct.field("sentiment_analysis_result", &self.sentiment_analysis_result);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "sessions")]
impl std::fmt::Debug for super::StreamingDetectIntentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamingDetectIntentRequest");
        debug_struct.field("session", &self.session);
        debug_struct.field("query_params", &self.query_params);
        debug_struct.field("query_input", &self.query_input);
        debug_struct.field("single_utterance", &self.single_utterance);
        debug_struct.field("output_audio_config", &self.output_audio_config);
        debug_struct.field("output_audio_config_mask", &self.output_audio_config_mask);
        debug_struct.field("input_audio", &self.input_audio);
        debug_struct.field("enable_debugging_info", &self.enable_debugging_info);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "participants", feature = "sessions",))]
impl std::fmt::Debug for super::CloudConversationDebuggingInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CloudConversationDebuggingInfo");
        debug_struct.field("audio_data_chunks", &self.audio_data_chunks);
        debug_struct.field("result_end_time_offset", &self.result_end_time_offset);
        debug_struct.field("first_audio_duration", &self.first_audio_duration);
        debug_struct.field("single_utterance", &self.single_utterance);
        debug_struct.field(
            "speech_partial_results_end_times",
            &self.speech_partial_results_end_times,
        );
        debug_struct.field(
            "speech_final_results_end_times",
            &self.speech_final_results_end_times,
        );
        debug_struct.field("partial_responses", &self.partial_responses);
        debug_struct.field(
            "speaker_id_passive_latency_ms_offset",
            &self.speaker_id_passive_latency_ms_offset,
        );
        debug_struct.field("bargein_event_triggered", &self.bargein_event_triggered);
        debug_struct.field("speech_single_utterance", &self.speech_single_utterance);
        debug_struct.field(
            "dtmf_partial_results_times",
            &self.dtmf_partial_results_times,
        );
        debug_struct.field("dtmf_final_results_times", &self.dtmf_final_results_times);
        debug_struct.field(
            "single_utterance_end_time_offset",
            &self.single_utterance_end_time_offset,
        );
        debug_struct.field("no_speech_timeout", &self.no_speech_timeout);
        debug_struct.field("endpointing_timeout", &self.endpointing_timeout);
        debug_struct.field("is_input_text", &self.is_input_text);
        debug_struct.field(
            "client_half_close_time_offset",
            &self.client_half_close_time_offset,
        );
        debug_struct.field(
            "client_half_close_streaming_time_offset",
            &self.client_half_close_streaming_time_offset,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "sessions")]
impl std::fmt::Debug for super::StreamingDetectIntentResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamingDetectIntentResponse");
        debug_struct.field("response_id", &self.response_id);
        debug_struct.field("recognition_result", &self.recognition_result);
        debug_struct.field("query_result", &self.query_result);
        debug_struct.field("webhook_status", &self.webhook_status);
        debug_struct.field("output_audio", &self.output_audio);
        debug_struct.field("output_audio_config", &self.output_audio_config);
        debug_struct.field("debugging_info", &self.debugging_info);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "participants", feature = "sessions",))]
impl std::fmt::Debug for super::StreamingRecognitionResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("StreamingRecognitionResult");
        debug_struct.field("message_type", &self.message_type);
        debug_struct.field("transcript", &self.transcript);
        debug_struct.field("is_final", &self.is_final);
        debug_struct.field("confidence", &self.confidence);
        debug_struct.field("speech_word_info", &self.speech_word_info);
        debug_struct.field("speech_end_offset", &self.speech_end_offset);
        debug_struct.field("language_code", &self.language_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "conversations",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::TextInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("TextInput");
        debug_struct.field("text", &self.text);
        debug_struct.field("language_code", &self.language_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "participants", feature = "sessions",))]
impl std::fmt::Debug for super::EventInput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("EventInput");
        debug_struct.field("name", &self.name);
        debug_struct.field("parameters", &self.parameters);
        debug_struct.field("language_code", &self.language_code);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(feature = "participants", feature = "sessions",))]
impl std::fmt::Debug for super::SentimentAnalysisRequestConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SentimentAnalysisRequestConfig");
        debug_struct.field(
            "analyze_query_text_sentiment",
            &self.analyze_query_text_sentiment,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "conversations",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::SentimentAnalysisResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SentimentAnalysisResult");
        debug_struct.field("query_text_sentiment", &self.query_text_sentiment);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "answer-records",
    feature = "conversations",
    feature = "participants",
    feature = "sessions",
))]
impl std::fmt::Debug for super::Sentiment {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Sentiment");
        debug_struct.field("score", &self.score);
        debug_struct.field("magnitude", &self.magnitude);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(any(
    feature = "participants",
    feature = "session-entity-types",
    feature = "sessions",
))]
impl std::fmt::Debug for super::SessionEntityType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("SessionEntityType");
        debug_struct.field("name", &self.name);
        debug_struct.field("entity_override_mode", &self.entity_override_mode);
        debug_struct.field("entities", &self.entities);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "session-entity-types")]
impl std::fmt::Debug for super::ListSessionEntityTypesRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSessionEntityTypesRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "session-entity-types")]
impl std::fmt::Debug for super::ListSessionEntityTypesResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListSessionEntityTypesResponse");
        debug_struct.field("session_entity_types", &self.session_entity_types);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "session-entity-types")]
impl std::fmt::Debug for super::GetSessionEntityTypeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetSessionEntityTypeRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "session-entity-types")]
impl std::fmt::Debug for super::CreateSessionEntityTypeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateSessionEntityTypeRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("session_entity_type", &self.session_entity_type);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "session-entity-types")]
impl std::fmt::Debug for super::UpdateSessionEntityTypeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateSessionEntityTypeRequest");
        debug_struct.field("session_entity_type", &self.session_entity_type);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "session-entity-types")]
impl std::fmt::Debug for super::DeleteSessionEntityTypeRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteSessionEntityTypeRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "agents")]
impl std::fmt::Debug for super::ValidationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ValidationError");
        debug_struct.field("severity", &self.severity);
        debug_struct.field("entries", &self.entries);
        debug_struct.field("error_message", &self.error_message);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "agents")]
impl std::fmt::Debug for super::ValidationResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ValidationResult");
        debug_struct.field("validation_errors", &self.validation_errors);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "versions")]
impl std::fmt::Debug for super::Version {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("Version");
        debug_struct.field("name", &self.name);
        debug_struct.field("description", &self.description);
        debug_struct.field("version_number", &self.version_number);
        debug_struct.field("create_time", &self.create_time);
        debug_struct.field("status", &self.status);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "versions")]
impl std::fmt::Debug for super::ListVersionsRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListVersionsRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("page_size", &self.page_size);
        debug_struct.field("page_token", &self.page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "versions")]
impl std::fmt::Debug for super::ListVersionsResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("ListVersionsResponse");
        debug_struct.field("versions", &self.versions);
        debug_struct.field("next_page_token", &self.next_page_token);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "versions")]
impl std::fmt::Debug for super::GetVersionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("GetVersionRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "versions")]
impl std::fmt::Debug for super::CreateVersionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("CreateVersionRequest");
        debug_struct.field("parent", &self.parent);
        debug_struct.field("version", &self.version);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "versions")]
impl std::fmt::Debug for super::UpdateVersionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("UpdateVersionRequest");
        debug_struct.field("version", &self.version);
        debug_struct.field("update_mask", &self.update_mask);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(feature = "versions")]
impl std::fmt::Debug for super::DeleteVersionRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("DeleteVersionRequest");
        debug_struct.field("name", &self.name);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(all(
    feature = "agents",
    feature = "answer-records",
    feature = "contexts",
    feature = "conversation-datasets",
    feature = "conversation-models",
    feature = "conversation-profiles",
    feature = "conversations",
    feature = "documents",
    feature = "encryption-spec-service",
    feature = "entity-types",
    feature = "environments",
    feature = "fulfillments",
    feature = "generators",
    feature = "intents",
    feature = "knowledge-bases",
    feature = "participants",
    feature = "session-entity-types",
    feature = "sessions",
    feature = "versions",
))]
impl std::fmt::Debug for super::WebhookRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WebhookRequest");
        debug_struct.field("session", &self.session);
        debug_struct.field("response_id", &self.response_id);
        debug_struct.field("query_result", &self.query_result);
        debug_struct.field(
            "original_detect_intent_request",
            &self.original_detect_intent_request,
        );
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(all(
    feature = "agents",
    feature = "answer-records",
    feature = "contexts",
    feature = "conversation-datasets",
    feature = "conversation-models",
    feature = "conversation-profiles",
    feature = "conversations",
    feature = "documents",
    feature = "encryption-spec-service",
    feature = "entity-types",
    feature = "environments",
    feature = "fulfillments",
    feature = "generators",
    feature = "intents",
    feature = "knowledge-bases",
    feature = "participants",
    feature = "session-entity-types",
    feature = "sessions",
    feature = "versions",
))]
impl std::fmt::Debug for super::WebhookResponse {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("WebhookResponse");
        debug_struct.field("fulfillment_text", &self.fulfillment_text);
        debug_struct.field("fulfillment_messages", &self.fulfillment_messages);
        debug_struct.field("source", &self.source);
        debug_struct.field("payload", &self.payload);
        debug_struct.field("output_contexts", &self.output_contexts);
        debug_struct.field("followup_event_input", &self.followup_event_input);
        debug_struct.field("session_entity_types", &self.session_entity_types);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}

#[cfg(all(
    feature = "agents",
    feature = "answer-records",
    feature = "contexts",
    feature = "conversation-datasets",
    feature = "conversation-models",
    feature = "conversation-profiles",
    feature = "conversations",
    feature = "documents",
    feature = "encryption-spec-service",
    feature = "entity-types",
    feature = "environments",
    feature = "fulfillments",
    feature = "generators",
    feature = "intents",
    feature = "knowledge-bases",
    feature = "participants",
    feature = "session-entity-types",
    feature = "sessions",
    feature = "versions",
))]
impl std::fmt::Debug for super::OriginalDetectIntentRequest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut debug_struct = f.debug_struct("OriginalDetectIntentRequest");
        debug_struct.field("source", &self.source);
        debug_struct.field("version", &self.version);
        debug_struct.field("payload", &self.payload);
        if !self._unknown_fields.is_empty() {
            debug_struct.field("_unknown_fields", &self._unknown_fields);
        }
        debug_struct.finish()
    }
}
